// 钱包混入
import walletManager from '@/api/walletManager.js';
import userService from '@/api/userService.js';
import web3WalletService from '@/api/web3.js';

export default {
  data() {
    return {
      // 钱包相关数据
      walletConnected: false,
      walletAddress: '', // 初始为空，只有登录成功后才显示
      // 用户相关数据
      userInfo: null,
	  userinfo:{},
      inviteCode: '',
      // 钱包管理器回调引用
      walletAddressChangeHandler: null,
      walletLoginHandler: null,
      // 控制自动登录的标志
      isAutoConnecting: false, // 是否正在自动连接（页面刷新/切换时）
      hasUserLoggedIn: false,   // 用户是否已经登录过
      // 邀请码弹窗相关
      inviteModalVisible: false,
      inviteModalConfig: null,
      inviteModalError: ''
    }
  },

  async onLoad() {
    // 初始化钱包管理器
    await walletManager.init(this.$i18n);
    
    // 初始化钱包监听
    this.initWalletListeners();
    
    // 检查钱包状态
    await this.checkWalletStatus();
    
    // 检查登录状态
    this.checkLoginStatus();
    
    console.log('📍 onLoad: walletAddress =', this.walletAddress);
  },

  // 检查登录状态
  checkLoginStatus() {
    const token = uni.getStorageSync('token');
    const currentAddress = walletManager.getCurrentAddress();
    
    if (token && currentAddress) {
      // 已经登录，显示钱包地址
      this.walletAddress = this.formatAddress(currentAddress);
      this.hasUserLoggedIn = true;
      this.walletConnected = true;
      console.log('✅ 检测到已登录状态，显示钱包地址:', this.walletAddress);
    } else {
      // 未登录
      this.walletAddress = '';
      this.hasUserLoggedIn = false;
      console.log('⚠️ 未登录状态');
    }
  },

  onShow() {
    // 页面显示时强制检查钱包地址
    this.forceCheckWalletAddress();
    
    // 同时更新当前钱包状态显示
    const currentAddress = walletManager.getCurrentAddress();
    const isConnected = walletManager.isWalletConnected();
    
    console.log('页面显示时检查钱包状态:', { currentAddress, isConnected });
    
    if (isConnected && currentAddress) {
      this.walletConnected = true;
      
      // 检查是否已经登录过（通过token判断）
      const token = uni.getStorageSync('token');
      if (token) {
        // 已经登录过，显示钱包地址
        this.walletAddress = this.formatAddress(currentAddress);
        this.hasUserLoggedIn = true;
        console.log('✅ 检测到已登录状态，显示钱包地址');
      } else {
        // 未登录，不显示地址
        this.walletAddress = '';
        this.hasUserLoggedIn = false;
        console.log('⚠️ 未登录状态，不显示钱包地址');
      }
    } else {
      this.walletConnected = false;
      this.walletAddress = '';
      this.hasUserLoggedIn = false;
    }
  },

  onUnload() {
    // 页面卸载时清理事件监听
    this.cleanupWalletListeners();
  },

  methods: {
    // 初始化钱包监听
    initWalletListeners() {
      // 绑定地址变化处理器
      this.walletAddressChangeHandler = this.handleWalletAddressChange.bind(this);
      walletManager.onAddressChange(this.walletAddressChangeHandler);
      
      // 绑定登录处理器
      this.walletLoginHandler = this.handleWalletLogin.bind(this);
      walletManager.onLogin(this.walletLoginHandler);
      
      console.log('钱包监听器已初始化');
    },

    // 清理钱包监听
    cleanupWalletListeners() {
      if (this.walletAddressChangeHandler) {
        walletManager.offAddressChange(this.walletAddressChangeHandler);
      }
      if (this.walletLoginHandler) {
        walletManager.offLogin(this.walletLoginHandler);
      }
    },

    // 处理钱包地址变化
    handleWalletAddressChange(oldAccount, newAccount) {
      console.log('🔄 页面收到钱包地址变化事件:', { oldAccount, newAccount });
      
      if (!oldAccount && newAccount) {
        // 新连接
        console.log('🆕 检测到新连接，调用 handleWalletConnected');
        this.handleWalletConnected(newAccount);
      } else if (oldAccount && !newAccount) {
        // 断开连接
        console.log('❌ 检测到断开连接，调用 handleWalletDisconnected');
        this.handleWalletDisconnected(oldAccount);
      } else if (oldAccount && newAccount && oldAccount !== newAccount) {
        // 地址切换
        console.log('🔄 检测到地址切换，调用 handleWalletSwitched');
        this.handleWalletSwitched(oldAccount, newAccount);
      }
    },

    // 处理钱包登录
    async handleWalletLogin(address) {
      console.log('页面收到钱包登录事件:', address);
      
      // 如果正在自动连接（页面刷新/切换），不触发登录
      if (this.isAutoConnecting) {
        console.log('⚠️ 正在自动连接中，跳过登录流程');
        return;
      }
      
      // 检查是否已经登录过（通过token判断）
      const token = uni.getStorageSync('token');
      if (token && this.hasUserLoggedIn) {
        console.log('⚠️ 用户已登录，跳过重复登录');
        return;
      }
      
      console.log('🚀 钱包已连接，开始自动签名登录流程');
      
      // 连接钱包后自动进行签名登录
      this.walletConnected = true;
      uni.setStorageSync('address', address);
      
      // 自动触发签名登录
      await this.handleSignatureLogin(address);
    },

    // 处理签名登录
    async handleSignatureLogin(address) {
      console.log('🚀 开始签名登录流程:', address);
      
      try {
        // 获取当前页面的邀请码
        const currentInviteCode = this.getCurrentInviteCode();
        console.log('📝 邀请码:', currentInviteCode);
        
        // 生成登录消息
        const message = web3WalletService.generateLoginMessage(address);
        console.log('📄 登录消息:', message);
        
        // 请求用户签名
        console.log('✍️ 请求用户签名...');
        const signResult = await web3WalletService.signMessage(message, address);
        
        if (!signResult.success) {
          console.error('❌ 签名失败:', signResult.error);
          uni.showToast({
            title: signResult.error || '签名失败',
            icon: 'none'
          });
          return;
        }
        
        console.log('✅ 签名成功:', signResult.signature);
        
        // 使用签名登录
        console.log('🔐 调用 Go API 签名登录接口...');
        const loginResult = await userService.goLoginWithSignature(
          address, 
          message, 
          signResult.signature, 
          currentInviteCode
        );
        
        if (loginResult.success) {
          console.log('🎉 签名登录成功');
          console.log('🎉 登录前 walletAddress =', this.walletAddress);
          
          // 登录成功后显示钱包地址
          this.walletAddress = this.formatAddress(address);
          console.log('🎉 登录后 walletAddress =', this.walletAddress);
          
          // 设置已登录标志
          this.hasUserLoggedIn = true;
          
          // 更新用户信息
          await this.updateUserInfo();
          
          // 显示登录成功提示，使用多语言转换
          const successMsg = this.translateApiMessage(loginResult.msg || '登录成功');
          uni.showToast({
            title: successMsg,
            icon: 'success'
          });
        } else {
          console.error('❌ 签名登录失败:', loginResult.error);
          console.log('❌ 错误详情:', JSON.stringify(loginResult));
          
          // 检查是否是邀请码错误
          if (loginResult.error === 'Errors' || loginResult.error === '邀请码无效') {
            console.log('📝 需要邀请码，显示邀请码输入弹窗');
            console.log('📝 错误类型:', loginResult.error);
            await this.showInviteCodeDialog(address, message, signResult.signature);
          } else {
            console.log('📝 其他错误，不显示邀请码弹窗:', loginResult.error);
            uni.showToast({
              title: loginResult.error || '签名登录失败',
              icon: 'none'
            });
          }
        }
      } catch (error) {
        console.error('💥 签名登录处理失败:', error);
        uni.showToast({
          title: '签名登录失败',
          icon: 'none'
        });
      }
    },

    // 处理钱包连接
    handleWalletConnected(account) {
      console.log('🔗 钱包已连接:', account);
      console.log('🔗 连接前 walletAddress =', this.walletAddress);
      this.walletConnected = true;
      // 不显示地址，等登录成功后再显示
      // this.walletAddress = ''; // 确保不显示地址
      console.log('🔗 连接后 walletAddress =', this.walletAddress);
      uni.setStorageSync('address', account);
    },

    // 处理钱包断开连接
    handleWalletDisconnected(account) {
      console.log('钱包已断开连接:', account);
      this.walletConnected = false;
      this.walletAddress = '';
      
      // 重置登录状态
      this.hasUserLoggedIn = false;
      
      // 清除用户数据
      userService.clearUserData();
      this.userInfo = null;
      this.inviteCode = '';
      
      // 显示断开连接提示
      uni.showToast({
        title: this.$t('wallet.disconnect_success'),
        icon: 'success'
      });
    },

    // 处理钱包地址切换
    async handleWalletSwitched(oldAccount, newAccount) {
      console.log('钱包地址已切换:', { oldAccount, newAccount });
      
      // 更新地址存储
      uni.setStorageSync('address', newAccount);
      
      // 重置登录状态
      this.hasUserLoggedIn = false;
      this.walletAddress = '';
      
      // 清除旧地址的数据
      userService.clearUserData();
      this.userInfo = null;
      this.inviteCode = '';
      
      // 地址变化时自动重新登录
      console.log('🔄 地址变化，自动重新登录');
      await this.handleSignatureLogin(newAccount);
    },

    // 强制检查钱包地址
    async forceCheckWalletAddress() {
      try {
        console.log('开始强制检查钱包地址...');
        const result = await walletManager.forceCheckWalletAddress();
        
        if (result.changed) {
          console.log('强制检查发现地址变化:', result);
          
          // 更新UI状态
          if (result.account) {
            this.walletConnected = true;
            // 检查登录状态，如果已登录则显示地址
            this.checkLoginStatus();
          } else {
            this.walletConnected = false;
            this.walletAddress = '';
            this.hasUserLoggedIn = false;
          }
        } else {
          console.log('强制检查未发现地址变化');
        }
        
        return result;
      } catch (error) {
        console.error('强制检查钱包地址失败:', error);
        return { changed: false, error: error.message };
      }
    },

    // 连接钱包
    async connectWallet() {
      try {
        console.log('🚀 用户主动连接钱包，当前 walletAddress =', this.walletAddress);
        
        // 清除自动连接标志，允许触发登录
        this.isAutoConnecting = false;
        
        uni.showLoading({
          title: this.$t('wallet.connecting')
        });

        const result = await walletManager.connectWallet();

        if (result.success) {
          console.log('✅ 钱包连接成功，等待事件监听处理');
          console.log('✅ 连接成功后 walletAddress =', this.walletAddress);
        } else {
          uni.showToast({
            title: result.error || this.$t('wallet.connect_failed'),
            icon: 'none'
          });
        }
      } catch (error) {
        uni.showToast({
          title: this.$t('wallet.connect_error'),
          icon: 'none'
        });
      } finally {
        uni.hideLoading();
      }
    },

    // 断开钱包连接
    disconnectWallet() {
      walletManager.disconnectWallet();
      this.walletConnected = false;
      this.walletAddress = '';
      
      // 重置登录状态
      this.hasUserLoggedIn = false;

      uni.showToast({
        title: this.$t('wallet.disconnect_success'),
        icon: 'success'
      });
    },

    // 检查钱包状态并自动连接
    async checkWalletStatus() {
      // 延迟检查，确保页面加载完成
      setTimeout(async () => {
        try {
          // 设置自动连接标志，避免触发登录
          this.isAutoConnecting = true;
          console.log('🔄 开始自动连接检查（页面刷新/切换）');
          
          // 尝试自动连接
          const result = await walletManager.autoConnect();

          if (result.success) {
            console.log('✅ 自动连接成功，更新页面状态（不触发登录）');
            // 直接更新页面状态，确保UI正确显示
            this.walletConnected = true;
            
            // 检查登录状态，如果已登录则显示地址
            this.checkLoginStatus();
            
            console.log('页面钱包状态已更新:', { 
              connected: this.walletConnected, 
              address: this.walletAddress 
            });
          } else {
            console.log(this.$t('wallet.auto_connect_failed'), result.error);
            // 确保断开状态正确显示
            this.walletConnected = false;
            this.walletAddress = '';
          }
        } catch (error) {
          console.error(this.$t('wallet.check_wallet_failed'), error);
          // 错误时也要确保状态正确
          this.walletConnected = false;
          this.walletAddress = '';
        } finally {
          // 清除自动连接标志
          this.isAutoConnecting = false;
          console.log('🔄 自动连接检查完成');
        }
      }, 1000);
    },

    // 更新用户信息
    async updateUserInfo() {
      try {
        // 使用 Go API 获取用户信息
        const result = await userService.getUserInfo();
        console.log('使用go更新用户信息',result);
        if (result.success) {
          this.userInfo = result.userInfo;
          this.inviteCode = result.userInfo?.yqm || '';
          uni.setStorageSync('userinfo', this.userInfo);
          // 触发用户信息更新事件
          this.$emit('userInfoUpdated', this.userInfo);
		  // console.error('更新用户信息:', this.userInfo);
        } else {
          console.error('更新用户信息失败:', result.error);
        }
      } catch (error) {
        console.error('更新用户信息失败:', error);
      }
    },

    // 获取当前邀请码（子类可以重写此方法）
    getCurrentInviteCode() {
      return this.inviteCode || uni.getStorageSync('yqm') || '';
    },

    // 格式化地址显示
    formatAddress(address, start = 6, end = 4) {
      if (!address) return '';
      return `${address.slice(0, start)}...${address.slice(-end)}`;
    },

    // 手动登录（用户点击登录按钮时调用）
    async manualLogin() {
      if (!this.walletConnected) {
        uni.showToast({
          title: '请先连接钱包',
          icon: 'none'
        });
        return;
      }

      // 获取当前钱包地址
      const currentAddress = walletManager.getCurrentAddress();
      if (!currentAddress) {
        uni.showToast({
          title: '钱包地址获取失败',
          icon: 'none'
        });
        return;
      }

      // 调用签名登录
      await this.handleSignatureLogin(currentAddress);
    },

    // 显示邀请码输入弹窗
    async showInviteCodeDialog(address, message, signature) {
      return new Promise((resolve) => {
        console.log('📝 准备显示邀请码弹窗');
        console.log('📝 参数:', { address, message, signature });
        
        // 获取多语言文本
        const title = this.$t ? this.$t('invite.title') : '邀请码验证';
        const placeholder = this.$t ? this.$t('invite.placeholder') : '请输入6位邀请码';
        const cancelText = this.$t ? this.$t('common.cancel') : '取消';
        const confirmText = this.$t ? this.$t('common.confirm') : '确定';
        
        console.log('📝 弹窗配置:', { title, placeholder, cancelText, confirmText });
        
        // 使用自定义弹窗组件
        this.showCustomInviteModal(address, message, signature, title, placeholder, cancelText, confirmText).then(resolve);
      });
    },

    // 显示自定义邀请码弹窗
    async showCustomInviteModal(address, message, signature, title, placeholder, cancelText, confirmText) {
      return new Promise((resolve) => {
        // 设置弹窗状态
        this.inviteModalVisible = true;
        this.inviteModalConfig = {
          title,
          placeholder,
          cancelText,
          confirmText,
          address,
          message,
          signature,
          resolve
        };
      });
    },

    // 处理邀请码弹窗确认
    async handleInviteModalConfirm(inviteCode) {
      const config = this.inviteModalConfig;
      const address = config.address;
      const message = config.message;
      const signature = config.signature;
      const resolve = config.resolve;
      
      try {
        console.log('📝 用户输入邀请码:', inviteCode);
        
        // 使用邀请码重新尝试登录
        const loginResult = await userService.goLoginWithSignature(
          address, 
          message, 
          signature, 
          inviteCode.trim()
        );
        
        if (loginResult.success) {
          console.log('🎉 邀请码登录成功');
          
          // 关闭弹窗
          this.inviteModalVisible = false;
          this.inviteModalConfig = null;
          
          // 登录成功后显示钱包地址
          this.walletAddress = this.formatAddress(address);
          
          // 设置已登录标志
          this.hasUserLoggedIn = true;
          
          // 更新用户信息
          await this.updateUserInfo();
          
          // 显示登录成功提示，使用多语言转换
          const successMsg = this.translateApiMessage(loginResult.msg || '注册成功');
          uni.showToast({
            title: successMsg,
            icon: 'success'
          });
          
          resolve(true);
        } else {
          console.error('❌ 邀请码登录失败:', loginResult.error);
          
          if (loginResult.error === 'Errors' || loginResult.error === '邀请码无效') {
            const invalidError = this.$t ? this.$t('invite.invalid_error') : '邀请码无效，请重新输入';
            // 显示错误信息在弹窗中
            this.inviteModalError = invalidError;
          } else {
            const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
            this.inviteModalError = loginResult.error || failedMsg;
          }
        }
      } catch (error) {
        console.error('💥 邀请码登录处理失败:', error);
        const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
        this.inviteModalError = failedMsg;
      }
    },

    // 处理邀请码弹窗取消
    handleInviteModalCancel() {
      const config = this.inviteModalConfig;
      const resolve = config.resolve;
      
      console.log('📝 用户取消输入邀请码');
      const requiredError = this.$t ? this.$t('invite.required_error') : '需要邀请码才能注册';
      uni.showToast({
        title: requiredError,
        icon: 'none'
      });
      
      // 关闭弹窗
      this.inviteModalVisible = false;
      this.inviteModalConfig = null;
      
      resolve(false);
    },


    // 使用 prompt 输入邀请码
    async promptInviteCode(address, message, signature) {
      return new Promise((resolve) => {
        const placeholder = this.$t ? this.$t('invite.placeholder') : '请输入6位邀请码';
        const title = this.$t ? this.$t('invite.title') : '邀请码验证';
        
        // 尝试使用 uni.prompt
        if (typeof uni.prompt === 'function') {
          uni.prompt({
            title: title,
            placeholder: placeholder,
            success: async (res) => {
              console.log('📝 prompt 回调:', res);
              if (res.confirm) {
                const inviteCode = res.content || '';
                console.log('📝 用户输入邀请码:', inviteCode);
                
                if (inviteCode.trim() === '') {
                  const emptyError = this.$t ? this.$t('invite.empty_error') : '请输入邀请码';
                  uni.showToast({
                    title: emptyError,
                    icon: 'none'
                  });
                  // 重新显示输入框
                  this.promptInviteCode(address, message, signature).then(resolve);
                  return;
                }
                
                // 使用邀请码重新尝试登录
                try {
                  const loginResult = await userService.goLoginWithSignature(
                    address, 
                    message, 
                    signature, 
                    inviteCode.trim()
                  );
                  
                  if (loginResult.success) {
                    console.log('🎉 邀请码登录成功');
                    
                    // 登录成功后显示钱包地址
                    this.walletAddress = this.formatAddress(address);
                    
                    // 设置已登录标志
                    this.hasUserLoggedIn = true;
                    
                    // 更新用户信息
                    await this.updateUserInfo();
                    
                    // 显示登录成功提示，使用多语言转换
                    const successMsg = this.translateApiMessage(loginResult.msg || '注册成功');
                    uni.showToast({
                      title: successMsg,
                      icon: 'success'
                    });
                    
                    resolve(true);
                  } else {
                    console.error('❌ 邀请码登录失败:', loginResult.error);
                    
                    if (loginResult.error === 'Errors' || loginResult.error === '邀请码无效') {
                      const invalidError = this.$t ? this.$t('invite.invalid_error') : '邀请码无效，请重新输入';
                      uni.showToast({
                        title: invalidError,
                        icon: 'none'
                      });
                      // 递归调用，让用户重新输入
                      this.promptInviteCode(address, message, signature).then(resolve);
                    } else {
                      const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
                      uni.showToast({
                        title: loginResult.error || failedMsg,
                        icon: 'none'
                      });
                      resolve(false);
                    }
                  }
                } catch (error) {
                  console.error('💥 邀请码登录处理失败:', error);
                  const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
                  uni.showToast({
                    title: failedMsg,
                    icon: 'none'
                  });
                  resolve(false);
                }
              } else {
                console.log('📝 用户取消输入邀请码');
                const requiredError = this.$t ? this.$t('invite.required_error') : '需要邀请码才能注册';
                uni.showToast({
                  title: requiredError,
                  icon: 'none'
                });
                resolve(false);
              }
            },
            fail: (error) => {
              console.log('📝 prompt 失败:', error);
              resolve(false);
            }
          });
        } else {
          // 如果 uni.prompt 不支持，使用 showModal 的 editable 属性
          console.log('📝 uni.prompt 不支持，使用 showModal editable');
          
          uni.showModal({
            title: title,
            content: '',
            editable: true,
            placeholderText: placeholder,
            showCancel: true,
            cancelText: this.$t ? this.$t('common.cancel') : '取消',
            confirmText: this.$t ? this.$t('common.confirm') : '确定',
            success: async (res) => {
              if (res.confirm) {
                const inviteCode = res.content || '';
                console.log('📝 用户输入邀请码:', inviteCode);
                
                if (inviteCode.trim() === '') {
                  const emptyError = this.$t ? this.$t('invite.empty_error') : '请输入邀请码';
                  uni.showToast({
                    title: emptyError,
                    icon: 'none'
                  });
                  // 重新显示输入框
                  this.promptInviteCode(address, message, signature).then(resolve);
                  return;
                }
                
                try {
                  const loginResult = await userService.goLoginWithSignature(
                    address, 
                    message, 
                    signature, 
                    inviteCode.trim()
                  );
                  
                  if (loginResult.success) {
                    console.log('🎉 邀请码登录成功');
                    this.walletAddress = this.formatAddress(address);
                    this.hasUserLoggedIn = true;
                    await this.updateUserInfo();
                    
                    // 显示登录成功提示，使用多语言转换
                    const successMsg = this.translateApiMessage(loginResult.msg || '注册成功');
                    uni.showToast({
                      title: successMsg,
                      icon: 'success'
                    });
                    
                    resolve(true);
                  } else {
                    console.error('❌ 邀请码登录失败:', loginResult.error);
                    
                    if (loginResult.error === 'Errors' || loginResult.error === '邀请码无效') {
                      const invalidError = this.$t ? this.$t('invite.invalid_error') : '邀请码无效，请重新输入';
                      uni.showToast({
                        title: invalidError,
                        icon: 'none'
                      });
                      // 递归调用，让用户重新输入
                      this.promptInviteCode(address, message, signature).then(resolve);
                    } else {
                      const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
                      uni.showToast({
                        title: loginResult.error || failedMsg,
                        icon: 'none'
                      });
                      resolve(false);
                    }
                  }
                } catch (error) {
                  console.error('💥 邀请码登录处理失败:', error);
                  const failedMsg = this.$t ? this.$t('invite.register_failed') : '注册失败';
                  uni.showToast({
                    title: failedMsg,
                    icon: 'none'
                  });
                  resolve(false);
                }
              } else {
                console.log('📝 用户取消输入邀请码');
                const requiredError = this.$t ? this.$t('invite.required_error') : '需要邀请码才能注册';
                uni.showToast({
                  title: requiredError,
                  icon: 'none'
                });
                resolve(false);
              }
            },
            fail: (error) => {
              console.log('📝 备用方案失败:', error);
              resolve(false);
            }
          });
        }
      });
    },

    // 转换接口消息的多语言
    translateApiMessage(message) {
      if (!message) return message;
      
      // 获取当前语言
      const currentLocale = this.$i18n ? this.$i18n.locale : 'zh';
      
      // 如果是中文环境，直接返回原消息
      if (currentLocale === 'zh') {
        return message;
      }
      
      // 如果是英文环境，尝试转换
      if (this.$t) {
        const translatedMessage = this.$t(`api_messages.${message}`);
        // 如果找到了翻译，返回翻译后的消息
        if (translatedMessage && translatedMessage !== `api_messages.${message}`) {
          return translatedMessage;
        }
      }
      
      // 如果没有找到翻译，返回原消息
      return message;
    }

  }
}
